package com.wlz.java8.lambda;
import org.junit.Test;

import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.function.Consumer;

/**
 * @author： wlz
 * @Date 2020/7/3 9:49
 * @description： TODO 基础语法
 * @version: 1.0
 *  左侧: Lambda表达式的参数列表
 *  右侧: Lambda表达式中所需执行的功能，即Lambda体
 *  依赖于函数时接口，Lambda表达式即对接口的实现
 *
 * 语法1：无参、无返回值
 * 语法2：有一个参数，无返回值
 * 语法3：只有一个参数,省略括号
 * 语法4:有两个以上的参数，有返回值，并且Lambda体中有多条语句
 * 语法5:Lambda体中只有一条语句，return 和大括号都可以省略不写
 *      Lambda表达式的参数列表的数据类型可以省略不写.JVM编译器通过上下文推断数据类型
 * 语法6:参数指定类型
 *
 *
 *
 * 上联:左右遇一括号省
 * 下联:左侧推断类型省
 * 横批:能省则省
 */
public class Demo2 {


    /**
     * 无参数，无返回值 对应格式为: ()-> 方法体... 括号内无参数
     */
    @Test
    public void test1() {
        Runnable run = new Runnable() {
            @Override
            public void run() {
                System.out.println("old run");
            }
        };
        run.run();

        System.out.println("------------------------");
        Runnable run1 = () -> System.out.println("lambda run");
        run1.run();
    }

    /**
     * 有一个参数,无返回值 （x）-> 方法体....   or    x -> 方法体...
     */
    @Test
    public void test2() {
        List<String> list = new ArrayList<>();
        //将consumer接收到的对象进行具体的功能的消费
        Consumer<String> consumer = (s) -> list.add(s);
        consumer.accept("ddd");
        consumer.accept("aaa");
        consumer.accept("ccc");
        list.forEach(System.out::println);

    }

    /**
     * 有两个参数或者两个以上的参数，有返回值，lambda 方法体中有多条语句
     *  语法:
     *      (x,y) -> {
     *          方法体
     *          return 返回值
     *      }
     *
     */
    @Test
    public void test3() {
        Comparator<Integer> comparator = (x,y) -> {
            System.out.println("x为"+x);
            System.out.println("y为"+y);
            return Integer.compare(x,y);
        };
        System.out.println(comparator.compare(1, 2));
    }

    /**
     * 有两个参数或者两个以上的参数，有返回值，lambda 如果方法体中只有一条语句,大括号可以省略，return 也可以省略
     *  语法:
     *      （x,y）-> 方法体
     *
     *  lambda 表达式的参数列表的 数据类型可以省略不写，因为jvm 编译器可以通过上下文推断出数据类型，即'类型推断'
     *   即：
     *      （Integer x,Integer y） -> Integer.compare(x,y);
     *   简化为:
     *       (x,y) -> Integer.compare(x,y);
     */
    @Test
    public void test4() {
        Comparator<Integer> comparator = (x,y) -> {
            return Integer.compare(x,y);
        };
        System.out.println(comparator.compare(1,2));

        // 简写
        Comparator<Integer> comparator1 = (x,y) -> Integer.compare(x,y);
        System.out.println(comparator1.compare(2,3));
    }




}
